home *** CD-ROM | disk | FTP | other *** search
/ Apple Developer Connection Student Program / ADC Tools Sampler CD Disk 3 1999.iso / Cool Demos, SDKs, & Tools / Demos⁄Tools⁄Offers / Eiffel for CW beta 3 / EiffelS2 / EIFFEL2.H < prev    next >
Encoding:
C/C++ Source or Header  |  1998-03-01  |  29.0 KB  |  725 lines  |  [TEXT/CWIE]
  1. #ifndef EIFFEL_S2
  2.  
  3. #define EIFFEL_S2       1       /* Eiffel2 included                 */
  4.  
  5. /*------------------------------------------------------------------*/
  6.  
  7. #ifdef  EDEBUG_2
  8. #define EDEBUG_1        1
  9. #endif
  10.  
  11. #ifdef  EDEBUG_1
  12. #define EDEBUG_0        1
  13. #endif
  14.  
  15. /*------------------------------------------------------------------*/
  16. /* Types                                                            */
  17. /*------------------------------------------------------------------*/
  18.  
  19. typedef unsigned char   BOOLEAN;
  20. typedef  char   CHARACTER;
  21. typedef double          DOUBLE;
  22. typedef long            INTEGER;
  23. typedef double          REAL;
  24. typedef unsigned char  *OBJREF;
  25. typedef unsigned char  *POINTER;
  26.  
  27. /*------------------------------------------------------------------*/
  28. /* Internal types                                                   */
  29. /*------------------------------------------------------------------*/
  30.  
  31. typedef short           INTEGER8;
  32. typedef short           INTEGER16;
  33.  
  34. /*------------------------------------------------------------------*/
  35.  
  36. typedef struct etype {
  37.  
  38.     POINTER         emod;       /* Module belonging to this type */
  39.     struct etype  **egen;       /* Generic parameters            */
  40.     INTEGER16       egencount;  /* Number of generic parameters  */
  41.     CHARACTER      *ebase;      /* Base class of type            */
  42.     CHARACTER      *ename;      /* Full type name                */
  43.     CHARACTER      *ecode;      /* Typecode; used for packing    */
  44.     INTEGER16       ebits;      /* Number of bits if BIT type    */    
  45.     BOOLEAN         expanded;   /* Is it an expanded type?       */
  46.     INTEGER         instances;  /* Nr of instances of type       */
  47.     INTEGER         eindex;     /* Used for packing              */
  48.     struct etype   *enext;      /* Used for packing              */
  49.  
  50. } ETYPE;
  51. /*------------------------------------------------------------------*/
  52. /* Macros                                                           */
  53. /*------------------------------------------------------------------*/
  54.  
  55. #define                 true        ((BOOLEAN) 1)
  56. #define                 false       ((BOOLEAN) 0)
  57. #define                 VOIDREF     ((OBJREF) 0)
  58.  
  59. /*------------------------------------------------------------------*/
  60. /* Builtin C functions                                              */
  61. /*------------------------------------------------------------------*/
  62.  
  63. #define Emset(ccc, iii)       (void) memset ((char *)(ccc), 0, (unsigned)(iii))
  64. #if defined(__MWERKS__)
  65. #define Esjmp(xxx)            setjmp((long**)xxx)
  66. #else
  67. #define Esjmp(xxx)            setjmp(xxx)
  68. #endif /* __MWERKS__ */
  69.  
  70. /*------------------------------------------------------------------*/
  71. /* Runtime frame                                                    */
  72. /*------------------------------------------------------------------*/
  73.  
  74. typedef union {
  75.  
  76.     INTEGER     _ires;      /* Integer   result         */
  77.     CHARACTER   _cres;      /* Character result         */
  78.     BOOLEAN     _bres;      /* Boolean   result         */
  79.     REAL        _rres;      /* Real      result         */
  80.     POINTER     _pres;      /* Pointer   result         */
  81.     OBJREF      _ores;      /* Objref    result         */
  82.     ETYPE      *_tres;      /* Type      result         */
  83.  
  84. } ERES_TYPES;
  85.  
  86. typedef struct rtf {
  87.  
  88.     INTEGER     *_iap;      /* Integer   arguments      */
  89.     CHARACTER   *_cap;      /* Character arguments      */
  90.     BOOLEAN     *_bap;      /* Boolean   arguments      */
  91.     REAL        *_rap;      /* Real      arguments      */
  92.     POINTER     *_pap;      /* Pointer   arguments      */
  93.     OBJREF      *_oap;      /* Objref    arguments      */
  94.     INTEGER16   _oac;       /* Number of objref  args   */
  95.     INTEGER     *_i;        /* Integer   locals         */
  96.     CHARACTER   *_c;        /* Character locals         */
  97.     BOOLEAN     *_b;        /* Boolean   locals         */
  98.     REAL        *_r;        /* Real      locals         */
  99.     POINTER     *_p;        /* Pointer   locals         */
  100.     OBJREF      *_o;        /* Objref    locals         */
  101.     INTEGER16   _oc;        /* Number of objref  locals */
  102.     ERES_TYPES  _res;       /* Any result               */
  103.     INTEGER16   etidx;      /* Index in definition table*/
  104.     INTEGER16   epos;       /* Current position         */
  105.     POINTER     emod;       /* Call module              */
  106.     struct rtf  *next;      /* Next runtime frame       */
  107.  
  108. } RTF;
  109. /*------------------------------------------------------------------*/
  110.  
  111. #define INIT_b(ddd,ttt)     {Emset(_b,(ddd)*sizeof(ttt));_mf._b = _b;}
  112. #define INIT_c(ddd,ttt)     {Emset(_c,(ddd)*sizeof(ttt));_mf._c = _c;}
  113. #define INIT_i(ddd,ttt)     {Emset(_i,(ddd)*sizeof(ttt));_mf._i = _i;}
  114. #define INIT_p(ddd,ttt)     {Emset(_p,(ddd)*sizeof(ttt));_mf._p = _p;}
  115. #define INIT_r(ddd,ttt)     {Emset(_r,(ddd)*sizeof(ttt));_mf._r = _r;}
  116. #define INIT_o(ddd,ttt)     {Emset(_o,(ddd)*sizeof(ttt));_mf._o = _o;_mf._oc = ddd;}
  117. #define INIT_oca(ddd,ttt)   {Emset(_oca,(ddd)*sizeof(ttt));_mf._oac = ddd;}
  118.  
  119. #define RTF_init(iii)       {Emset((&_mf),(sizeof(RTF)));\
  120.                              _cfp->next = &_mf;\
  121.                              _mf.etidx = (iii);\
  122.                              _mf.emod = (POINTER) &md;}
  123.  
  124. #define RTF_restore         {_mf.next = (RTF *) 0; *(md.erec) = _arec;}
  125. #define RTF_return          (_cfp->next = (RTF *) 0);
  126.  
  127. /*------------------------------------------------------------------*/
  128. /* Function pointers                                                */
  129. /*------------------------------------------------------------------*/
  130.  
  131. typedef void                (*EPER)(RTF *, BOOLEAN, INTEGER);
  132.  
  133. /*------------------------------------------------------------------*/
  134. /* Library / class name pairs                                       */
  135. /*------------------------------------------------------------------*/
  136.  
  137. typedef struct {
  138.  
  139.     INTEGER16   elib;       /* Name of library         */
  140.     INTEGER16   eclass;     /* Name of class           */
  141.     POINTER     emod;       /* The module of this pair */
  142.  
  143. } ELCP;
  144.  
  145. /*------------------------------------------------------------------*/
  146. /* Parent table entries                                             */
  147. /*------------------------------------------------------------------*/
  148.  
  149. typedef struct {
  150.  
  151.     CHARACTER   ekind;      /* Kind of entry    */
  152.     INTEGER16   eidx;       /* Index in library/class name pair table */
  153.     INTEGER16   eclause;    /* Inheritance clause */
  154.     INTEGER16   ename1;     /* First feature name */
  155.     INTEGER16   ename2;     /* Second feature name */
  156.     EPER        ptype;      /* Typeof parent */
  157.  
  158. } EPAR;
  159.  
  160. /*------------------------------------------------------------------*/
  161. /* Dispatch table entries                                           */
  162. /*------------------------------------------------------------------*/
  163.  
  164. /* Routine dispatch structures */
  165.  
  166. typedef struct {
  167.  
  168.     EPER        erp;    /* Pointer to routine      */
  169.     INTEGER16   ecnr;   /* Class number            */
  170.  
  171. } ERDLE;
  172.  
  173. typedef struct {
  174.  
  175.     EPER        erp;    /* Pointer to routine      */
  176.     INTEGER16   elcp;   /* Index of ELCP structure */
  177.     INTEGER16   ename;  /* Name of routine         */
  178.     ERDLE      *elist;  /* Dispatch list           */
  179.     INTEGER16   ecount; /* Number of entries in dispatch list */    
  180.  
  181. } ERDS;
  182.  
  183. /* Data dispatch structures */
  184.  
  185. typedef struct {
  186.  
  187.     INTEGER16   eoff;   /* Offset of data          */
  188.     INTEGER16   ecnr;   /* Class number            */
  189.  
  190. } EDDLE;
  191.  
  192. typedef struct {
  193.  
  194.     INTEGER16   eoff;   /* Offset of data          */
  195.     INTEGER16   elcp;   /* Index of ELCP structure */
  196.     INTEGER16   ename;  /* Name of routine         */
  197.     EDDLE      *elist;  /* Dispatch list           */
  198.     INTEGER16   ecount; /* Number of entries in dispatch list */    
  199.     
  200. } EDDS;
  201.  
  202. /* Typeof dispatch structures */
  203.  
  204. typedef struct {
  205.  
  206.     EPER        erp;    /* Pointer to routine      */
  207.     INTEGER16   ecnr;   /* Class number            */
  208.  
  209. } ETDLE;
  210.  
  211. typedef struct {
  212.  
  213.     EPER        erp;    /* Pointer to routine      */
  214.     INTEGER16   elcp;   /* Index of ELCP structure */
  215.     INTEGER16   ename;  /* Name of routine         */
  216.     ETDLE      *elist;  /* Dispatch list           */
  217.     INTEGER16   ecount; /* Number of entries in dispatch list */    
  218.     
  219. } ETDS;
  220. /*------------------------------------------------------------------*/
  221. /* Dispatch macros                                                  */
  222. /*------------------------------------------------------------------*/
  223.  
  224. #ifdef  EFINAL
  225.  
  226. #define     Erdisp(mmm,tgt,idx)     (((POINTER) (Erdt[idx].erp)) == ((POINTER) (md.edefrout))) ? ((*(md.erdisp))(mmm, tgt, idx)) : (POINTER) (Erdt[idx].erp)
  227. #define     Eddisp(mmm,tgt,idx)     (Eddt[idx].eoff) ? Eaddrof((tgt), (Eddt [idx].eoff)) : ((*(md.eddisp))(mmm, tgt, idx))
  228. #define     Etdisp(mmm,tgt,idx)     ((*(md.etdisp))(mmm, tgt, idx))
  229.  
  230. #else
  231.  
  232. #define     Erdisp(mmm,tgt,idx)     (((POINTER) (Erdt[idx].erp)) == ((POINTER) (md.edefrout))) ? ((*(md.erdisp))(mmm, tgt, idx)) : (POINTER) (Erdt[idx].erp)
  233. #define     Eddisp(mmm,tgt,idx)     ((tgt) && Eddt[idx].eoff) ? Eaddrof((tgt), (Eddt [idx].eoff)) : ((*(md.eddisp))(mmm, tgt, idx))
  234. #define     Etdisp(mmm,tgt,idx)     ((*(md.etdisp))(mmm, tgt, idx))
  235.  
  236. #endif
  237.  
  238. #define     Erhdisp(mmm,tgt,idx)    (((POINTER) (Erdt[idx].erp)) == ((POINTER) (md.edefrout))) ? ((*(md.erhdisp))(mmm, tgt, idx)) : (POINTER) (Erdt[idx].erp)
  239. #define     Edhdisp(mmm,tgt,idx)    ((tgt) && Eddt[idx].eoff) ? Eaddrof((tgt), (Eddt [idx].eoff)) : ((*(md.edhdisp))(mmm, tgt, idx))
  240. #define     Ethdisp(mmm,tgt,idx)    ((*(md.ethdisp))(mmm, tgt, idx))
  241. #define     Echup(hhh)              ((hhh) ? (hhh) : (*(md.evdisp))())
  242. /*------------------------------------------------------------------*/
  243. /* Routine and attribute definition tables                          */
  244. /*------------------------------------------------------------------*/
  245.  
  246. typedef struct {
  247.  
  248.     INTEGER16   ename;      /* Name of routine            */
  249.     EPER        eaddr;      /* Address of routine         */
  250.     EPER        etaddr;     /* Address of typeof function */
  251.     INTEGER16   esig;       /* Signature                  */
  252.     POINTER     ebreak;     /* Break points               */
  253.     POINTER     emod;       /* Module pointer for Cecil   */
  254.  
  255. } ERDEF;
  256.  
  257. typedef struct {
  258.  
  259.     INTEGER16   ename;      /* Name of attribute          */
  260.     INTEGER16   eoff;       /* Offset in data structure   */
  261.     EPER        etaddr;     /* Address of typeof function */
  262.     CHARACTER   ekind;      /* Type indicator             */
  263.     INTEGER16   esig;       /* Signature                  */
  264.  
  265. } EDDEF;
  266.  
  267. /*------------------------------------------------------------------*/
  268. /* Externals                                                        */
  269. /*------------------------------------------------------------------*/
  270.  
  271. typedef struct {
  272.  
  273.     POINTER     eaddr;          /* Address of external routine   */
  274.     INTEGER16   ename;          /* True name of external routine */
  275.  
  276. } EERS;
  277.  
  278. typedef struct {
  279.  
  280.     POINTER     eaddr;          /* Address of external routine   */
  281.     CHARACTER  *ename;          /* True name of external routine */
  282.  
  283. } RT_EERS;
  284.  
  285. /*------------------------------------------------------------------*/
  286.  
  287. typedef struct {
  288.  
  289.     ETYPE       *etd;       /* A type descriptor       */
  290.     INTEGER16   elcp;       /* Index in ELCP structure */
  291.  
  292. } ETS;
  293.  
  294. /*------------------------------------------------------------------*/
  295. /* Debug tables                                                     */
  296. /*------------------------------------------------------------------*/
  297.  
  298. typedef struct {
  299.  
  300.     CHARACTER  *ekey;       /* Debug key                    */
  301.     INTEGER16   eidx;       /* Index of debug instruction   */
  302.  
  303. } EDBKS;
  304. /*------------------------------------------------------------------*/
  305. /* Multi branch tables                                              */
  306. /*------------------------------------------------------------------*/
  307.  
  308. typedef struct {
  309.  
  310.     INTEGER     elower;     /* Lower interval bound */
  311.     INTEGER     eupper;     /* Upper interval bound */
  312.     INTEGER16   ecode;      /* Code number          */
  313.  
  314. } EMBS;
  315.  
  316. #define Esel(ttt,iii)       ((*(md.esel))(ttt,iii))
  317.  
  318. /*------------------------------------------------------------------*/
  319. /* Module descriptor                                                */
  320. /*------------------------------------------------------------------*/
  321.  
  322. typedef struct mdesc {
  323.  
  324.     CHARACTER   *ename;
  325.     CHARACTER   *elib;
  326.     ETYPE       *etype;
  327.     INTEGER16   ecnr;                      /* Class number */
  328.     INTEGER16   esize;                     /* Size of an object */
  329.  
  330.     POINTER     (*erdisp)(RTF *, OBJREF, INTEGER);  /* Runtime routine dispatcher    */
  331.     POINTER     (*eddisp)(RTF *, OBJREF, INTEGER);  /* Runtime data   dispatcher    */
  332.     POINTER     (*etdisp)(RTF *, OBJREF, INTEGER);  /* Runtime type  dispatcher    */
  333.     POINTER     (*erhdisp)(RTF *, OBJREF, INTEGER);  /* Runtime routine dispatcher    */
  334.     POINTER     (*edhdisp)(RTF *, OBJREF, INTEGER);  /* Runtime data   dispatcher    */
  335.     POINTER     (*ethdisp)(RTF *, OBJREF, INTEGER);  /* Runtime type  dispatcher    */
  336.     POINTER     (*evdisp)(void);
  337.     void        (*edefrout)(RTF *, BOOLEAN, INTEGER);  /* Default routine = Runtime call through dispatcher */
  338.     int         (*esel)(EMBS *, INTEGER);  /* Runtime multi branch selection*/
  339.     OBJREF      (*ecreate)(RTF *, ETYPE *);/* Runtime object creation       */
  340.     OBJREF      (*ebitcreate)(RTF *, CHARACTER *, ETYPE *);
  341.     OBJREF      (*estrcreate)(RTF *, CHARACTER *, ETYPE *);
  342.     void        (*einit)(RTF *);           /* Module object initialization */
  343.     void        (*rinit)(RTF *);           /* Runtime object initialization */
  344.     void        (*enoichk)(void);          /* Runtime class inv. disable    */
  345.     void        (*echkvar)(INTEGER, INTEGER);
  346.                                            /* Runtime loop variant check */
  347.     void        (*eraise)(void);           /* Raise pending exceptions */
  348.     BOOLEAN     (*exnotify)(BOOLEAN, int, char *);
  349.     void        (*embex)(void);            /* Raise multi-branch exception*/
  350.                                            /* Exception notify */
  351.     BOOLEAN     (*exclr)(BOOLEAN);         /* Clear exceptions */
  352.     void        (*exvoid)(void);           /* Void target exception */
  353.     OBJREF      (*eiref)(INTEGER);         /* Reference version */
  354.     OBJREF      (*ecref)(CHARACTER);         /* Reference version */
  355.     OBJREF      (*ebref)(BOOLEAN);         /* Reference version */
  356.     OBJREF      (*erref)(REAL);         /* Reference version */
  357.     OBJREF      (*epref)(POINTER);         /* Reference version */
  358.     ETYPE*      (*egentype)(ETYPE *, int, ...);
  359.                                            /* Generic type creation */
  360.     ETYPE*      (*ebittype)(ETYPE *, int); /* Bittype creation */
  361.     BOOLEAN     (*eequal)(OBJREF, OBJREF); /* Standard equal */
  362.     INTEGER     (*eipow)(INTEGER, INTEGER);/* Integer power operator */
  363.     REAL        (*erpow)(REAL, INTEGER);   /* Real power operator */
  364.  
  365.     OBJREF      (*enewbarr)(OBJREF, INTEGER, INTEGER);
  366.     OBJREF      (*enewcarr)(OBJREF, INTEGER, INTEGER);
  367.     OBJREF      (*enewearr)(OBJREF, INTEGER, INTEGER);
  368.     OBJREF      (*enewiarr)(OBJREF, INTEGER, INTEGER);
  369.     OBJREF      (*enewoarr)(OBJREF, INTEGER, INTEGER);
  370.     OBJREF      (*enewparr)(OBJREF, INTEGER, INTEGER);
  371.     OBJREF      (*enewrarr)(OBJREF, INTEGER, INTEGER);
  372.     void        (*ecarrput)(OBJREF, CHARACTER, INTEGER);
  373.     void        (*ebarrput)(OBJREF, BOOLEAN, INTEGER);
  374.     void        (*eearrput)(OBJREF, OBJREF, INTEGER);
  375.     void        (*eiarrput)(OBJREF, INTEGER, INTEGER);
  376.     void        (*eoarrput)(OBJREF, OBJREF, INTEGER);
  377.     void        (*eparrput)(OBJREF, POINTER, INTEGER);
  378.     void        (*erarrput)(OBJREF, REAL, INTEGER);
  379.     CHARACTER   (*ecarritem)(OBJREF, INTEGER);
  380.     BOOLEAN     (*ebarritem)(OBJREF, INTEGER);
  381.     OBJREF      (*eearritem)(OBJREF, INTEGER);
  382.     INTEGER     (*eiarritem)(OBJREF, INTEGER);
  383.     OBJREF      (*eoarritem)(OBJREF, INTEGER);
  384.     POINTER     (*eparritem)(OBJREF, INTEGER);
  385.     REAL        (*erarritem)(OBJREF, INTEGER);
  386.     OBJREF      (*eassat)(ETYPE *, OBJREF); /* Assignment attempt */
  387.     OBJREF      (*eclone)(OBJREF);          /* Standard clone */
  388.     void        (*ecopy)(OBJREF, OBJREF);   /* Standard copy */
  389.     int*        (*enewenv)(void);           /* New environment (setjmp) */
  390.     void        (*efreeenv)(int**);
  391.     void        (*eprotect)(OBJREF *, INTEGER); /* Protect from GC */
  392.     EPER        eclinv;                    /* Runtime class invariant check */
  393.  
  394.     EPER        einv;                      /* Own class invariant routine   */
  395.  
  396.     void        (*epos)(RTF *, RTF *, INTEGER, POINTER);
  397.     void        (*einout)(RTF *, RTF *, BOOLEAN, POINTER);
  398.     ELCP        *elcp;
  399.     ETS         *ett;
  400.     EDDS        *eddt;
  401.     ERDS        *erdt;
  402.     ETDS        *etdt;
  403.     EERS        *eert;
  404.     ERDEF       *erdef;
  405.     EDDEF       *eddef;
  406.     BOOLEAN     *edbt;
  407.     EDBKS       *edbkt;
  408.  
  409.     BOOLEAN     elinv;                     /* Loop invariant checks */
  410.     BOOLEAN     elvar;                     /* Loop variant checks   */
  411.     BOOLEAN     echk;                      /* Check assertions      */
  412.     BOOLEAN     epre;                      /* Preconditions         */
  413.     BOOLEAN     epost;                     /* Postconditions        */
  414.     BOOLEAN     edbg;                      /* Debug instructions    */
  415.     BOOLEAN     ecinv;                     /* Class invariant       */
  416.     INTEGER     *erec;                     /* Assertion recursion   */
  417.  
  418.     EPAR        *epart;                    /* Parent table */
  419.     POINTER     plinks;
  420.     POINTER     dlinks;
  421.     POINTER     memory;
  422.     BOOLEAN     eattrs;
  423.  
  424.     INTEGER16   eidata [16];               /* Offsets of intrinsic data */
  425.     EPER        eirout [16];               /* Addresses of intrinsic routines */
  426.     CHARACTER   espec_kind;                /* Kind of special object */
  427.     BOOLEAN     ebreak;                    /* Does it have break points?*/
  428.  
  429.     char        **estr;
  430.     char        **eestr;
  431.  
  432.     struct mdesc    *enext;
  433.  
  434. } EMDESC;
  435. /*------------------------------------------------------------------*/
  436.  
  437. #define Ecreate         (*(md.ecreate))
  438. #define Ebitcreate      (*(md.ebitcreate))
  439. #define Estrcreate      (*(md.estrcreate))
  440. #define Eclone          (*(md.eclone))
  441. #define Ecopy           (*(md.ecopy))
  442. #define Einit           (*(md.rinit))
  443. #define Ecreation       (*(md.enoichk))
  444. #define Eclinv(fff,qqq) (*(md.eclinv))(fff,qqq,0)
  445. #define Eraise          (*(md.eraise))
  446. #define Eexnotify       (*(md.exnotify))
  447. #define Eexclr(bbb)     (*(md.exclr))((BOOLEAN)(bbb))
  448. #define Eiref           (*(md.eiref))
  449. #define Ecref           (*(md.ecref))
  450. #define Ebref           (*(md.ebref))
  451. #define Erref           (*(md.erref))
  452. #define Epref           (*(md.epref))
  453. #define Eiwrap          (*(md.eiref))
  454. #define Ecwrap          (*(md.ecref))
  455. #define Ebwrap          (*(md.ebref))
  456. #define Erwrap          (*(md.erref))
  457. #define Epwrap          (*(md.epref))
  458. #define Egentype        (*(md.egentype))
  459. #define Ebittype        (*(md.ebittype))
  460. #define Eequal          (*(md.eequal))
  461. #define Eipow           (*(md.eipow))
  462. #define Erpow           (*(md.erpow))
  463.  
  464. #define Enewbarr        (*(md.enewbarr))
  465. #define Enewcarr        (*(md.enewcarr))
  466. #define Enewearr        (*(md.enewearr))
  467. #define Enewiarr        (*(md.enewiarr))
  468. #define Enewoarr        (*(md.enewoarr))
  469. #define Enewparr        (*(md.enewparr))
  470. #define Enewrarr        (*(md.enewrarr))
  471.  
  472. #define Ebarrput        (*(md.ebarrput))
  473. #define Ecarrput        (*(md.ecarrput))
  474. #define Eearrput        (*(md.eearrput))
  475. #define Eiarrput        (*(md.eiarrput))
  476. #define Eoarrput        (*(md.eoarrput))
  477. #define Eparrput        (*(md.eparrput))
  478. #define Erarrput        (*(md.erarrput))
  479.  
  480. #define Enew_env        (*(md.enewenv))
  481. #define Efree_env       (*(md.efreeenv))
  482. #define Echkvar         (*(md.echkvar))
  483. #define Embex           (*(md.embex))
  484. #define Eassat          (*(md.eassat))
  485. #define Eprotect        (*(md.eprotect))
  486.  
  487. /*------------------------------------------------------------------*/
  488.  
  489. typedef union {
  490.  
  491.     EMDESC      *mod;
  492.     POINTER     hdr;
  493.  
  494. } EGPU;
  495.  
  496. typedef struct {
  497.  
  498.     ETYPE       *type;
  499.     EGPU        gpu;
  500.     INTEGER     gct;
  501.  
  502. } EHDR;
  503. /*------------------------------------------------------------------*/
  504.  
  505. #define Eheader(ooo)        ((EHDR *)(((char *) (ooo)) - sizeof (EHDR)))
  506. #define Etypeof(ooo)        (Eheader(ooo)->type)
  507. #define Eactgen(iii)        ((Etypeof((*(_cfp->_oap)))->egen)[iii])
  508. #define Eaddrof(ooo,iii)    ((POINTER) (((char *) (ooo))+((iii)-1)))
  509. #define Emodof(ooo)         ((Eheader(ooo)->gpu).mod)
  510.  
  511. /*------------------------------------------------------------------*/
  512. /* Assertion control                                                */
  513. /*------------------------------------------------------------------*/
  514.  
  515. #if defined(__MWERKS__)
  516. /* The recursion control stuff does not seem to be implemented fully.
  517.    It will be important for at least class invariants. */
  518. #define Elinv               (md.elinv)
  519. #define Elvar               (md.elvar)
  520. #define Echk                (md.echk)
  521. #define Epre                (md.epre)
  522. #define Epost               (md.epost)
  523. #define Epost_old           (md.epost)
  524. #define Edbg                (md.edbg)
  525. #define Ecinv               (md.ecinv)
  526. #else
  527. #define Elinv               (md.elinv && !(*md.erec) && (++(*(md.erec))))
  528. #define Elvar               (md.elvar && !(*md.erec) && (++(*(md.erec))))
  529. #define Echk                (md.echk && !(*md.erec) && (++(*(md.erec))))
  530. #define Epre                (md.epre && !(*md.erec) && (++(*(md.erec))))
  531. #define Epost               (md.epost && !(*md.erec) && (++(*(md.erec))))
  532. #define Epost_old           (md.epost && !(*md.erec))
  533. #define Edbg                (md.edbg && !(*md.erec) && (++(*(md.erec))))
  534. #define Ecinv               (md.ecinv && !(*md.erec) && (++(*(md.erec))))
  535. #endif /* __MWERKS__ */
  536.  
  537. #define EPCV                1           /* precondition violation   */
  538. #define EPOCV               2           /* postcondition   "        */
  539. #define ECHKV               3           /* check assertions "       */
  540. #define ELINV               4           /* loop invariant           */
  541. #define ELVAV               5           /* loop variant             */
  542. #define ECINV               6           /* class invariant          */
  543.  
  544. /*------------------------------------------------------------------*/
  545. /* Intrinsic Macros                                                 */
  546. /*------------------------------------------------------------------*/
  547.  
  548. #define  EI_IIEQ(xx,yy)       ((xx)==(yy))
  549. #define  EI_IEQ(oo,xx,yy)     ((xx)==(yy))
  550. #define  EI_ICP(xx,yy)        (xx = (yy))
  551. #define  EI_ICL(oo,xx)        (xx)
  552. #define  EI_IDCL(oo,xx)       (xx)
  553. #define  EI_IDEQ(oo,xx,yy)    ((xx)==(yy))
  554. #define  EI_IMIN(xx,yy)       (((xx)<(yy)) ? (xx) : (yy))
  555. #define  EI_IMAX(xx,yy)       (((yy)<(xx)) ? (xx) : (yy))
  556. #define  EI_ICMP(xx,yy)       ((xx)-(yy))
  557. #define  EI_IHSH(xx)          (((xx)<0) ? -(xx) : (xx))
  558.  
  559. #define  EI_CIEQ(xx,yy)       ((xx)==(yy))
  560. #define  EI_CEQ(oo,xx,yy)     ((xx)==(yy))
  561. #define  EI_CCP(xx,yy)        (xx = (yy))
  562. #define  EI_CCL(oo,xx)        (xx)
  563. #define  EI_CDCL(oo,xx)       (xx)
  564. #define  EI_CDEQ(oo,xx,yy)    ((xx)==(yy))
  565. #define  EI_CMIN(xx,yy)       (((xx)<(yy)) ? (xx) : (yy))
  566. #define  EI_CMAX(xx,yy)       (((yy)<(xx)) ? (xx) : (yy))
  567. #define  EI_CCMP(xx,yy)       (((int)(xx))-((int) (yy)))
  568. #define  EI_CHSH(xx)          ((INTEGER)((unsigned char) (xx)))
  569.  
  570. #define  EI_RIEQ(xx,yy)       ((xx)==(yy))
  571. #define  EI_REQ(oo,xx,yy)     ((xx)==(yy))
  572. #define  EI_RCP(xx,yy)        (xx = (yy))
  573. #define  EI_RCL(oo,xx)        (xx)
  574. #define  EI_RDCL(oo,xx)       (xx)
  575. #define  EI_RDEQ(oo,xx,yy)    ((xx)==(yy))
  576. #define  EI_RMIN(xx,yy)       (((xx)<(yy)) ? (xx) : (yy))
  577. #define  EI_RMAX(xx,yy)       (((yy)<(xx)) ? (xx) : (yy))
  578. #define  EI_RCMP(xx,yy)       (((xx)<(yy)) ? -1 : (((xx)>(yy)) ? 1 : 0))
  579. #define  EI_RHSH(xx)          (0)
  580.  
  581. #define  EI_BIEQ(xx,yy)       ((xx)==(yy))
  582. #define  EI_BEQ(oo,xx,yy)     ((xx)==(yy))
  583. #define  EI_BCP(xx,yy)        (xx = (yy))
  584. #define  EI_BCL(oo,xx)        (xx)
  585. #define  EI_BDCL(oo,xx)       (xx)
  586. #define  EI_BDEQ(oo,xx,yy)    ((xx)==(yy))
  587.  
  588. #define  EI_PIEQ(xx,yy)       ((xx)==(yy))
  589. #define  EI_PEQ(oo,xx,yy)     ((xx)==(yy))
  590. #define  EI_PCP(xx,yy)        (xx = (yy))
  591. #define  EI_PCL(oo,xx)        (xx)
  592. #define  EI_PDCL(oo,xx)       (xx)
  593. #define  EI_PDEQ(oo,xx,yy)    ((xx)==(yy))
  594.  
  595. /*------------------------------------------------------------------*/
  596. /* Offsets of intrinsic data                                        */
  597. /*------------------------------------------------------------------*/
  598.  
  599. #define EI_AR_OFF        0          /* Offset of area           */
  600. #define EI_CO_OFF        1          /* Offset of count          */
  601. #define EI_EX_OFF        2          /* Offset of exchg          */
  602. #define EI_FA_OFF        3          /* Offset of faptr          */
  603. #define EI_LI_OFF        4          /* Offset of lit            */
  604. #define EI_LO_OFF        5          /* Offset of lower          */
  605. #define EI_SP_OFF        6          /* Offest of special        */
  606. #define EI_UP_OFF        7          /* Offset of upper          */
  607.  
  608. #define EI_IDATA(ooo,nnn)  Eaddrof((ooo),((Emodof(ooo)->eidata)[nnn]))
  609.  
  610. #ifdef  EFINAL
  611.  
  612. #define EI_BAITM(ooo,iii)  ((*((BOOLEAN**)EI_IDATA(ooo,EI_FA_OFF)))[iii])
  613. #define EI_CAITM(ooo,iii)  ((*((CHARACTER**)EI_IDATA(ooo,EI_FA_OFF)))[iii])
  614. #define EI_EAITM(ooo,iii)  ((*((OBJREF**)EI_IDATA(ooo,EI_FA_OFF)))[iii])
  615. #define EI_IAITM(ooo,iii)  ((*((INTEGER**)EI_IDATA(ooo,EI_FA_OFF)))[iii])
  616. #define EI_OAITM(ooo,iii)  ((*((OBJREF**)EI_IDATA(ooo,EI_FA_OFF)))[iii])
  617. #define EI_PAITM(ooo,iii)  ((*((POINTER**)EI_IDATA(ooo,EI_FA_OFF)))[iii])
  618. #define EI_RAITM(ooo,iii)  ((*((REAL**)EI_IDATA(ooo,EI_FA_OFF)))[iii])
  619.  
  620. #define EI_BAPUT(ooo,xxx,iii)  (((*((BOOLEAN**)EI_IDATA(ooo,EI_FA_OFF)))[iii])=xxx)
  621. #define EI_CAPUT(ooo,xxx,iii)  (((*((CHARACTER**)EI_IDATA(ooo,EI_FA_OFF)))[iii])=xxx)
  622. #define EI_EAPUT(ooo,xxx,iii)  (((*((OBJREF**)EI_IDATA(ooo,EI_FA_OFF)))[iii])=xxx)
  623. #define EI_IAPUT(ooo,xxx,iii)  (((*((INTEGER**)EI_IDATA(ooo,EI_FA_OFF)))[iii])=xxx)
  624. #define EI_OAPUT(ooo,xxx,iii)  (((*((OBJREF**)EI_IDATA(ooo,EI_FA_OFF)))[iii])=xxx)
  625. #define EI_PAPUT(ooo,xxx,iii)  (((*((POINTER**)EI_IDATA(ooo,EI_FA_OFF)))[iii])=xxx)
  626. #define EI_RAPUT(ooo,xxx,iii)  (((*((REAL**)EI_IDATA(ooo,EI_FA_OFF)))[iii])=xxx)
  627.  
  628.  
  629. #else
  630.  
  631. #define EI_BAITM(ooo,iii)       (md.ebarritem((ooo),(iii)))
  632. #define EI_CAITM(ooo,iii)       (md.ecarritem((ooo),(iii)))
  633. #define EI_EAITM(ooo,iii)       (md.eearritem((ooo),(iii)))
  634. #define EI_IAITM(ooo,iii)       (md.eiarritem((ooo),(iii)))
  635. #define EI_OAITM(ooo,iii)       (md.eoarritem((ooo),(iii)))
  636. #define EI_PAITM(ooo,iii)       (md.eparritem((ooo),(iii)))
  637. #define EI_RAITM(ooo,iii)       (md.erarritem((ooo),(iii)))
  638.  
  639. #define EI_BAPUT(ooo,xxx,iii)   (md.ebarrput((ooo),(xxx),(iii)))
  640. #define EI_CAPUT(ooo,xxx,iii)   (md.ecarrput((ooo),(xxx),(iii)))
  641. #define EI_EAPUT(ooo,xxx,iii)   (md.eearrput((ooo),(xxx),(iii)))
  642. #define EI_IAPUT(ooo,xxx,iii)   (md.eiarrput((ooo),(xxx),(iii)))
  643. #define EI_OAPUT(ooo,xxx,iii)   (md.eoarrput((ooo),(xxx),(iii)))
  644. #define EI_PAPUT(ooo,xxx,iii)   (md.eparrput((ooo),(xxx),(iii)))
  645. #define EI_RAPUT(ooo,xxx,iii)   (md.erarrput((ooo),(xxx),(iii)))
  646.  
  647. #endif
  648.  
  649. #define EI_BALOW(ooo)      (*((INTEGER *)EI_IDATA(ooo,EI_LO_OFF)))
  650. #define EI_CALOW(ooo)      (*((INTEGER *)EI_IDATA(ooo,EI_LO_OFF)))
  651. #define EI_EALOW(ooo)      (*((INTEGER *)EI_IDATA(ooo,EI_LO_OFF)))
  652. #define EI_IALOW(ooo)      (*((INTEGER *)EI_IDATA(ooo,EI_LO_OFF)))
  653. #define EI_OALOW(ooo)      (*((INTEGER *)EI_IDATA(ooo,EI_LO_OFF)))
  654. #define EI_PALOW(ooo)      (*((INTEGER *)EI_IDATA(ooo,EI_LO_OFF)))
  655. #define EI_RALOW(ooo)      (*((INTEGER *)EI_IDATA(ooo,EI_LO_OFF)))
  656.  
  657. #define EI_BAUP(ooo)      (*((INTEGER *)EI_IDATA(ooo,EI_UP_OFF)))
  658. #define EI_CAUP(ooo)      (*((INTEGER *)EI_IDATA(ooo,EI_UP_OFF)))
  659. #define EI_EAUP(ooo)      (*((INTEGER *)EI_IDATA(ooo,EI_UP_OFF)))
  660. #define EI_IAUP(ooo)      (*((INTEGER *)EI_IDATA(ooo,EI_UP_OFF)))
  661. #define EI_OAUP(ooo)      (*((INTEGER *)EI_IDATA(ooo,EI_UP_OFF)))
  662. #define EI_PAUP(ooo)      (*((INTEGER *)EI_IDATA(ooo,EI_UP_OFF)))
  663. #define EI_RAUP(ooo)      (*((INTEGER *)EI_IDATA(ooo,EI_UP_OFF)))
  664.  
  665. /*------------------------------------------------------------------*/
  666. /* Addresses of intrinsic routines                                  */
  667. /*------------------------------------------------------------------*/
  668.  
  669. #define EI_CP_ADR       0       /* copy */
  670. #define EI_EQ_ADR       1       /* is_equal */
  671.  
  672. /*------------------------------------------------------------------*/
  673.  
  674. #if defined(__MWERKS__)
  675. #include <setjmp.h>
  676. #else
  677. #define setjmp  _setjmp
  678.  
  679. /*------------------------------------------------------------------*/
  680.  
  681. extern  int     setjmp (int *);
  682. #endif /* __MWERKS__ */
  683.  
  684. /*------------------------------------------------------------------*/
  685.  
  686. #ifdef EDEBUG_2
  687.  
  688. #define EPOS(ppp)           {(*(md.epos))(_cfp, &_mf, ppp, (POINTER)emap);}
  689. #define ENTER               {(*(md.einout))(_cfp, &_mf,false,(POINTER)emap);}
  690. #define LEAVE               {(*(md.einout))(_cfp, &_mf,true,(POINTER)emap);}
  691. #define EMOD
  692.  
  693. #else
  694.  
  695. #ifndef EFINAL
  696.  
  697. #define EPOS(ppp)
  698. #define ENTER  if ((_cfp->_oap != (OBJREF *) 0) && (*(_cfp->_oap) == VOIDREF)) (*(md.exvoid))();
  699. #define LEAVE
  700. #define EMOD
  701.  
  702. #else
  703.  
  704. #define EPOS(ppp)
  705. #define ENTER
  706. #define LEAVE
  707. #define EMOD
  708.  
  709. #endif
  710.  
  711. #endif
  712. /*------------------------------------------------------------------*/
  713.  
  714. typedef struct {
  715.  
  716.     INTEGER16   ename;
  717.     INTEGER16   cname;
  718.  
  719. } EMAP;
  720.  
  721. #endif /* EIFFEL_S2 */
  722.  
  723. /*------------------------------------------------------------------*/
  724.  
  725.